/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_matmul_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>
#include <vector>

#include "test/matmul/fixture.h"
#include "test/types/kernel_data_types.h"
#include "test/types/to_gtest_types.h"

using DataTypeList = sycldnn::types::KernelDataTypes;
using GTestTypeList = sycldnn::types::ToGTestTypes<DataTypeList>::type;

template <typename DataType>
using MatmulBatch1Beta1TrueTrue = MatmulFixture<DataType, true, true>;
TYPED_TEST_SUITE(MatmulBatch1Beta1TrueTrue, GTestTypeList);
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12846.,  30879.,  48912.,  66945.,  84978.,  103011., 121044., 139077.,
      157110., 175143., 193176., 211209., 229242., 247275., 12965.,  31194.,
      49423.,  67652.,  85881.,  104110., 122339., 140568., 158797., 177026.,
      195255., 213484., 231713., 249942., 13084.,  31509.,  49934.,  68359.,
      86784.,  105209., 123634., 142059., 160484., 178909., 197334., 215759.,
      234184., 252609., 13203.,  31824.,  50445.,  69066.,  87687.,  106308.,
      124929., 143550., 162171., 180792., 199413., 218034., 236655., 255276.,
      13322.,  32139.,  50956.,  69773.,  88590.,  107407., 126224., 145041.,
      163858., 182675., 201492., 220309., 239126., 257943., 13441.,  32454.,
      51467.,  70480.,  89493.,  108506., 127519., 146532., 165545., 184558.,
      203571., 222584., 241597., 260610., 13560.,  32769.,  51978.,  71187.,
      90396.,  109605., 128814., 148023., 167232., 186441., 205650., 224859.,
      244068., 263277., 13679.,  33084.,  52489.,  71894.,  91299.,  110704.,
      130109., 149514., 168919., 188324., 207729., 227134., 246539., 265944.,
      13798.,  33399.,  53000.,  72601.,  92202.,  111803., 131404., 151005.,
      170606., 190207., 209808., 229409., 249010., 268611., 13917.,  33714.,
      53511.,  73308.,  93105.,  112902., 132699., 152496., 172293., 192090.,
      211887., 231684., 251481., 271278., 14036.,  34029.,  54022.,  74015.,
      94008.,  114001., 133994., 153987., 173980., 193973., 213966., 233959.,
      253952., 273945., 14155.,  34344.,  54533.,  74722.,  94911.,  115100.,
      135289., 155478., 175667., 195856., 216045., 236234., 256423., 276612.,
      14274.,  34659.,  55044.,  75429.,  95814.,  116199., 136584., 156969.,
      177354., 197739., 218124., 238509., 258894., 279279., 14393.,  34974.,
      55555.,  76136.,  96717.,  117298., 137879., 158460., 179041., 199622.,
      220203., 240784., 261365., 281946.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12846.,  30879.,  48912.,  66945.,  84978.,  103011., 121044., 139077.,
      157110., 175143., 193176., 211209., 229242., 247275., 265308., 12966.,
      31195.,  49424.,  67653.,  85882.,  104111., 122340., 140569., 158798.,
      177027., 195256., 213485., 231714., 249943., 268172., 13086.,  31511.,
      49936.,  68361.,  86786.,  105211., 123636., 142061., 160486., 178911.,
      197336., 215761., 234186., 252611., 271036., 13206.,  31827.,  50448.,
      69069.,  87690.,  106311., 124932., 143553., 162174., 180795., 199416.,
      218037., 236658., 255279., 273900., 13326.,  32143.,  50960.,  69777.,
      88594.,  107411., 126228., 145045., 163862., 182679., 201496., 220313.,
      239130., 257947., 276764., 13446.,  32459.,  51472.,  70485.,  89498.,
      108511., 127524., 146537., 165550., 184563., 203576., 222589., 241602.,
      260615., 279628., 13566.,  32775.,  51984.,  71193.,  90402.,  109611.,
      128820., 148029., 167238., 186447., 205656., 224865., 244074., 263283.,
      282492., 13686.,  33091.,  52496.,  71901.,  91306.,  110711., 130116.,
      149521., 168926., 188331., 207736., 227141., 246546., 265951., 285356.,
      13806.,  33407.,  53008.,  72609.,  92210.,  111811., 131412., 151013.,
      170614., 190215., 209816., 229417., 249018., 268619., 288220., 13926.,
      33723.,  53520.,  73317.,  93114.,  112911., 132708., 152505., 172302.,
      192099., 211896., 231693., 251490., 271287., 291084., 14046.,  34039.,
      54032.,  74025.,  94018.,  114011., 134004., 153997., 173990., 193983.,
      213976., 233969., 253962., 273955., 293948., 14166.,  34355.,  54544.,
      74733.,  94922.,  115111., 135300., 155489., 175678., 195867., 216056.,
      236245., 256434., 276623., 296812., 14286.,  34671.,  55056.,  75441.,
      95826.,  116211., 136596., 156981., 177366., 197751., 218136., 238521.,
      258906., 279291., 299676., 14406.,  34987.,  55568.,  76149.,  96730.,
      117311., 137892., 158473., 179054., 199635., 220216., 240797., 261378.,
      281959., 302540.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      12846.,  30879.,  48912.,  66945.,  84978.,  103011., 121044., 139077.,
      157110., 175143., 193176., 211209., 229242., 247275., 265308., 283341.,
      12967.,  31196.,  49425.,  67654.,  85883.,  104112., 122341., 140570.,
      158799., 177028., 195257., 213486., 231715., 249944., 268173., 286402.,
      13088.,  31513.,  49938.,  68363.,  86788.,  105213., 123638., 142063.,
      160488., 178913., 197338., 215763., 234188., 252613., 271038., 289463.,
      13209.,  31830.,  50451.,  69072.,  87693.,  106314., 124935., 143556.,
      162177., 180798., 199419., 218040., 236661., 255282., 273903., 292524.,
      13330.,  32147.,  50964.,  69781.,  88598.,  107415., 126232., 145049.,
      163866., 182683., 201500., 220317., 239134., 257951., 276768., 295585.,
      13451.,  32464.,  51477.,  70490.,  89503.,  108516., 127529., 146542.,
      165555., 184568., 203581., 222594., 241607., 260620., 279633., 298646.,
      13572.,  32781.,  51990.,  71199.,  90408.,  109617., 128826., 148035.,
      167244., 186453., 205662., 224871., 244080., 263289., 282498., 301707.,
      13693.,  33098.,  52503.,  71908.,  91313.,  110718., 130123., 149528.,
      168933., 188338., 207743., 227148., 246553., 265958., 285363., 304768.,
      13814.,  33415.,  53016.,  72617.,  92218.,  111819., 131420., 151021.,
      170622., 190223., 209824., 229425., 249026., 268627., 288228., 307829.,
      13935.,  33732.,  53529.,  73326.,  93123.,  112920., 132717., 152514.,
      172311., 192108., 211905., 231702., 251499., 271296., 291093., 310890.,
      14056.,  34049.,  54042.,  74035.,  94028.,  114021., 134014., 154007.,
      174000., 193993., 213986., 233979., 253972., 273965., 293958., 313951.,
      14177.,  34366.,  54555.,  74744.,  94933.,  115122., 135311., 155500.,
      175689., 195878., 216067., 236256., 256445., 276634., 296823., 317012.,
      14298.,  34683.,  55068.,  75453.,  95838.,  116223., 136608., 156993.,
      177378., 197763., 218148., 238533., 258918., 279303., 299688., 320073.,
      14419.,  35000.,  55581.,  76162.,  96743.,  117324., 137905., 158486.,
      179067., 199648., 220229., 240810., 261391., 281972., 302553., 323134.};
  const int batches = 1;
  const int m = 14;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15801.,  38077.,  60353.,  82629.,  104905., 127181., 149457., 171733.,
      194009., 216285., 238561., 260837., 283113., 305389., 15935.,  38436.,
      60937.,  83438.,  105939., 128440., 150941., 173442., 195943., 218444.,
      240945., 263446., 285947., 308448., 16069.,  38795.,  61521.,  84247.,
      106973., 129699., 152425., 175151., 197877., 220603., 243329., 266055.,
      288781., 311507., 16203.,  39154.,  62105.,  85056.,  108007., 130958.,
      153909., 176860., 199811., 222762., 245713., 268664., 291615., 314566.,
      16337.,  39513.,  62689.,  85865.,  109041., 132217., 155393., 178569.,
      201745., 224921., 248097., 271273., 294449., 317625., 16471.,  39872.,
      63273.,  86674.,  110075., 133476., 156877., 180278., 203679., 227080.,
      250481., 273882., 297283., 320684., 16605.,  40231.,  63857.,  87483.,
      111109., 134735., 158361., 181987., 205613., 229239., 252865., 276491.,
      300117., 323743., 16739.,  40590.,  64441.,  88292.,  112143., 135994.,
      159845., 183696., 207547., 231398., 255249., 279100., 302951., 326802.,
      16873.,  40949.,  65025.,  89101.,  113177., 137253., 161329., 185405.,
      209481., 233557., 257633., 281709., 305785., 329861., 17007.,  41308.,
      65609.,  89910.,  114211., 138512., 162813., 187114., 211415., 235716.,
      260017., 284318., 308619., 332920., 17141.,  41667.,  66193.,  90719.,
      115245., 139771., 164297., 188823., 213349., 237875., 262401., 286927.,
      311453., 335979., 17275.,  42026.,  66777.,  91528.,  116279., 141030.,
      165781., 190532., 215283., 240034., 264785., 289536., 314287., 339038.,
      17409.,  42385.,  67361.,  92337.,  117313., 142289., 167265., 192241.,
      217217., 242193., 267169., 292145., 317121., 342097., 17543.,  42744.,
      67945.,  93146.,  118347., 143548., 168749., 193950., 219151., 244352.,
      269553., 294754., 319955., 345156.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15801.,  38077.,  60353.,  82629.,  104905., 127181., 149457., 171733.,
      194009., 216285., 238561., 260837., 283113., 305389., 327665., 15936.,
      38437.,  60938.,  83439.,  105940., 128441., 150942., 173443., 195944.,
      218445., 240946., 263447., 285948., 308449., 330950., 16071.,  38797.,
      61523.,  84249.,  106975., 129701., 152427., 175153., 197879., 220605.,
      243331., 266057., 288783., 311509., 334235., 16206.,  39157.,  62108.,
      85059.,  108010., 130961., 153912., 176863., 199814., 222765., 245716.,
      268667., 291618., 314569., 337520., 16341.,  39517.,  62693.,  85869.,
      109045., 132221., 155397., 178573., 201749., 224925., 248101., 271277.,
      294453., 317629., 340805., 16476.,  39877.,  63278.,  86679.,  110080.,
      133481., 156882., 180283., 203684., 227085., 250486., 273887., 297288.,
      320689., 344090., 16611.,  40237.,  63863.,  87489.,  111115., 134741.,
      158367., 181993., 205619., 229245., 252871., 276497., 300123., 323749.,
      347375., 16746.,  40597.,  64448.,  88299.,  112150., 136001., 159852.,
      183703., 207554., 231405., 255256., 279107., 302958., 326809., 350660.,
      16881.,  40957.,  65033.,  89109.,  113185., 137261., 161337., 185413.,
      209489., 233565., 257641., 281717., 305793., 329869., 353945., 17016.,
      41317.,  65618.,  89919.,  114220., 138521., 162822., 187123., 211424.,
      235725., 260026., 284327., 308628., 332929., 357230., 17151.,  41677.,
      66203.,  90729.,  115255., 139781., 164307., 188833., 213359., 237885.,
      262411., 286937., 311463., 335989., 360515., 17286.,  42037.,  66788.,
      91539.,  116290., 141041., 165792., 190543., 215294., 240045., 264796.,
      289547., 314298., 339049., 363800., 17421.,  42397.,  67373.,  92349.,
      117325., 142301., 167277., 192253., 217229., 242205., 267181., 292157.,
      317133., 342109., 367085., 17556.,  42757.,  67958.,  93159.,  118360.,
      143561., 168762., 193963., 219164., 244365., 269566., 294767., 319968.,
      345169., 370370.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15801.,  38077.,  60353.,  82629.,  104905., 127181., 149457., 171733.,
      194009., 216285., 238561., 260837., 283113., 305389., 327665., 349941.,
      15937.,  38438.,  60939.,  83440.,  105941., 128442., 150943., 173444.,
      195945., 218446., 240947., 263448., 285949., 308450., 330951., 353452.,
      16073.,  38799.,  61525.,  84251.,  106977., 129703., 152429., 175155.,
      197881., 220607., 243333., 266059., 288785., 311511., 334237., 356963.,
      16209.,  39160.,  62111.,  85062.,  108013., 130964., 153915., 176866.,
      199817., 222768., 245719., 268670., 291621., 314572., 337523., 360474.,
      16345.,  39521.,  62697.,  85873.,  109049., 132225., 155401., 178577.,
      201753., 224929., 248105., 271281., 294457., 317633., 340809., 363985.,
      16481.,  39882.,  63283.,  86684.,  110085., 133486., 156887., 180288.,
      203689., 227090., 250491., 273892., 297293., 320694., 344095., 367496.,
      16617.,  40243.,  63869.,  87495.,  111121., 134747., 158373., 181999.,
      205625., 229251., 252877., 276503., 300129., 323755., 347381., 371007.,
      16753.,  40604.,  64455.,  88306.,  112157., 136008., 159859., 183710.,
      207561., 231412., 255263., 279114., 302965., 326816., 350667., 374518.,
      16889.,  40965.,  65041.,  89117.,  113193., 137269., 161345., 185421.,
      209497., 233573., 257649., 281725., 305801., 329877., 353953., 378029.,
      17025.,  41326.,  65627.,  89928.,  114229., 138530., 162831., 187132.,
      211433., 235734., 260035., 284336., 308637., 332938., 357239., 381540.,
      17161.,  41687.,  66213.,  90739.,  115265., 139791., 164317., 188843.,
      213369., 237895., 262421., 286947., 311473., 335999., 360525., 385051.,
      17297.,  42048.,  66799.,  91550.,  116301., 141052., 165803., 190554.,
      215305., 240056., 264807., 289558., 314309., 339060., 363811., 388562.,
      17433.,  42409.,  67385.,  92361.,  117337., 142313., 167289., 192265.,
      217241., 242217., 267193., 292169., 317145., 342121., 367097., 392073.,
      17569.,  42770.,  67971.,  93172.,  118373., 143574., 168775., 193976.,
      219177., 244378., 269579., 294780., 319981., 345182., 370383., 395584.};
  const int batches = 1;
  const int m = 14;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19177.,  46314.,  73451.,  100588., 127725., 154862., 181999., 209136.,
      236273., 263410., 290547., 317684., 344821., 371958., 19327.,  46720.,
      74113.,  101506., 128899., 156292., 183685., 211078., 238471., 265864.,
      293257., 320650., 348043., 375436., 19477.,  47126.,  74775.,  102424.,
      130073., 157722., 185371., 213020., 240669., 268318., 295967., 323616.,
      351265., 378914., 19627.,  47532.,  75437.,  103342., 131247., 159152.,
      187057., 214962., 242867., 270772., 298677., 326582., 354487., 382392.,
      19777.,  47938.,  76099.,  104260., 132421., 160582., 188743., 216904.,
      245065., 273226., 301387., 329548., 357709., 385870., 19927.,  48344.,
      76761.,  105178., 133595., 162012., 190429., 218846., 247263., 275680.,
      304097., 332514., 360931., 389348., 20077.,  48750.,  77423.,  106096.,
      134769., 163442., 192115., 220788., 249461., 278134., 306807., 335480.,
      364153., 392826., 20227.,  49156.,  78085.,  107014., 135943., 164872.,
      193801., 222730., 251659., 280588., 309517., 338446., 367375., 396304.,
      20377.,  49562.,  78747.,  107932., 137117., 166302., 195487., 224672.,
      253857., 283042., 312227., 341412., 370597., 399782., 20527.,  49968.,
      79409.,  108850., 138291., 167732., 197173., 226614., 256055., 285496.,
      314937., 344378., 373819., 403260., 20677.,  50374.,  80071.,  109768.,
      139465., 169162., 198859., 228556., 258253., 287950., 317647., 347344.,
      377041., 406738., 20827.,  50780.,  80733.,  110686., 140639., 170592.,
      200545., 230498., 260451., 290404., 320357., 350310., 380263., 410216.,
      20977.,  51186.,  81395.,  111604., 141813., 172022., 202231., 232440.,
      262649., 292858., 323067., 353276., 383485., 413694., 21127.,  51592.,
      82057.,  112522., 142987., 173452., 203917., 234382., 264847., 295312.,
      325777., 356242., 386707., 417172.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19177.,  46314.,  73451.,  100588., 127725., 154862., 181999., 209136.,
      236273., 263410., 290547., 317684., 344821., 371958., 399095., 19328.,
      46721.,  74114.,  101507., 128900., 156293., 183686., 211079., 238472.,
      265865., 293258., 320651., 348044., 375437., 402830., 19479.,  47128.,
      74777.,  102426., 130075., 157724., 185373., 213022., 240671., 268320.,
      295969., 323618., 351267., 378916., 406565., 19630.,  47535.,  75440.,
      103345., 131250., 159155., 187060., 214965., 242870., 270775., 298680.,
      326585., 354490., 382395., 410300., 19781.,  47942.,  76103.,  104264.,
      132425., 160586., 188747., 216908., 245069., 273230., 301391., 329552.,
      357713., 385874., 414035., 19932.,  48349.,  76766.,  105183., 133600.,
      162017., 190434., 218851., 247268., 275685., 304102., 332519., 360936.,
      389353., 417770., 20083.,  48756.,  77429.,  106102., 134775., 163448.,
      192121., 220794., 249467., 278140., 306813., 335486., 364159., 392832.,
      421505., 20234.,  49163.,  78092.,  107021., 135950., 164879., 193808.,
      222737., 251666., 280595., 309524., 338453., 367382., 396311., 425240.,
      20385.,  49570.,  78755.,  107940., 137125., 166310., 195495., 224680.,
      253865., 283050., 312235., 341420., 370605., 399790., 428975., 20536.,
      49977.,  79418.,  108859., 138300., 167741., 197182., 226623., 256064.,
      285505., 314946., 344387., 373828., 403269., 432710., 20687.,  50384.,
      80081.,  109778., 139475., 169172., 198869., 228566., 258263., 287960.,
      317657., 347354., 377051., 406748., 436445., 20838.,  50791.,  80744.,
      110697., 140650., 170603., 200556., 230509., 260462., 290415., 320368.,
      350321., 380274., 410227., 440180., 20989.,  51198.,  81407.,  111616.,
      141825., 172034., 202243., 232452., 262661., 292870., 323079., 353288.,
      383497., 413706., 443915., 21140.,  51605.,  82070.,  112535., 143000.,
      173465., 203930., 234395., 264860., 295325., 325790., 356255., 386720.,
      417185., 447650.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M14xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      19177.,  46314.,  73451.,  100588., 127725., 154862., 181999., 209136.,
      236273., 263410., 290547., 317684., 344821., 371958., 399095., 426232.,
      19329.,  46722.,  74115.,  101508., 128901., 156294., 183687., 211080.,
      238473., 265866., 293259., 320652., 348045., 375438., 402831., 430224.,
      19481.,  47130.,  74779.,  102428., 130077., 157726., 185375., 213024.,
      240673., 268322., 295971., 323620., 351269., 378918., 406567., 434216.,
      19633.,  47538.,  75443.,  103348., 131253., 159158., 187063., 214968.,
      242873., 270778., 298683., 326588., 354493., 382398., 410303., 438208.,
      19785.,  47946.,  76107.,  104268., 132429., 160590., 188751., 216912.,
      245073., 273234., 301395., 329556., 357717., 385878., 414039., 442200.,
      19937.,  48354.,  76771.,  105188., 133605., 162022., 190439., 218856.,
      247273., 275690., 304107., 332524., 360941., 389358., 417775., 446192.,
      20089.,  48762.,  77435.,  106108., 134781., 163454., 192127., 220800.,
      249473., 278146., 306819., 335492., 364165., 392838., 421511., 450184.,
      20241.,  49170.,  78099.,  107028., 135957., 164886., 193815., 222744.,
      251673., 280602., 309531., 338460., 367389., 396318., 425247., 454176.,
      20393.,  49578.,  78763.,  107948., 137133., 166318., 195503., 224688.,
      253873., 283058., 312243., 341428., 370613., 399798., 428983., 458168.,
      20545.,  49986.,  79427.,  108868., 138309., 167750., 197191., 226632.,
      256073., 285514., 314955., 344396., 373837., 403278., 432719., 462160.,
      20697.,  50394.,  80091.,  109788., 139485., 169182., 198879., 228576.,
      258273., 287970., 317667., 347364., 377061., 406758., 436455., 466152.,
      20849.,  50802.,  80755.,  110708., 140661., 170614., 200567., 230520.,
      260473., 290426., 320379., 350332., 380285., 410238., 440191., 470144.,
      21001.,  51210.,  81419.,  111628., 141837., 172046., 202255., 232464.,
      262673., 292882., 323091., 353300., 383509., 413718., 443927., 474136.,
      21153.,  51618.,  82083.,  112548., 143013., 173478., 203943., 234408.,
      264873., 295338., 325803., 356268., 386733., 417198., 447663., 478128.};
  const int batches = 1;
  const int m = 14;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13756.,  33063.,  52370.,  71677.,  90984.,  110291., 129598., 148905.,
      168212., 187519., 206826., 226133., 245440., 264747., 13875.,  33378.,
      52881.,  72384.,  91887.,  111390., 130893., 150396., 169899., 189402.,
      208905., 228408., 247911., 267414., 13994.,  33693.,  53392.,  73091.,
      92790.,  112489., 132188., 151887., 171586., 191285., 210984., 230683.,
      250382., 270081., 14113.,  34008.,  53903.,  73798.,  93693.,  113588.,
      133483., 153378., 173273., 193168., 213063., 232958., 252853., 272748.,
      14232.,  34323.,  54414.,  74505.,  94596.,  114687., 134778., 154869.,
      174960., 195051., 215142., 235233., 255324., 275415., 14351.,  34638.,
      54925.,  75212.,  95499.,  115786., 136073., 156360., 176647., 196934.,
      217221., 237508., 257795., 278082., 14470.,  34953.,  55436.,  75919.,
      96402.,  116885., 137368., 157851., 178334., 198817., 219300., 239783.,
      260266., 280749., 14589.,  35268.,  55947.,  76626.,  97305.,  117984.,
      138663., 159342., 180021., 200700., 221379., 242058., 262737., 283416.,
      14708.,  35583.,  56458.,  77333.,  98208.,  119083., 139958., 160833.,
      181708., 202583., 223458., 244333., 265208., 286083., 14827.,  35898.,
      56969.,  78040.,  99111.,  120182., 141253., 162324., 183395., 204466.,
      225537., 246608., 267679., 288750., 14946.,  36213.,  57480.,  78747.,
      100014., 121281., 142548., 163815., 185082., 206349., 227616., 248883.,
      270150., 291417., 15065.,  36528.,  57991.,  79454.,  100917., 122380.,
      143843., 165306., 186769., 208232., 229695., 251158., 272621., 294084.,
      15184.,  36843.,  58502.,  80161.,  101820., 123479., 145138., 166797.,
      188456., 210115., 231774., 253433., 275092., 296751., 15303.,  37158.,
      59013.,  80868.,  102723., 124578., 146433., 168288., 190143., 211998.,
      233853., 255708., 277563., 299418., 15422.,  37473.,  59524.,  81575.,
      103626., 125677., 147728., 169779., 191830., 213881., 235932., 257983.,
      280034., 302085.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13756.,  33063.,  52370.,  71677.,  90984.,  110291., 129598., 148905.,
      168212., 187519., 206826., 226133., 245440., 264747., 284054., 13876.,
      33379.,  52882.,  72385.,  91888.,  111391., 130894., 150397., 169900.,
      189403., 208906., 228409., 247912., 267415., 286918., 13996.,  33695.,
      53394.,  73093.,  92792.,  112491., 132190., 151889., 171588., 191287.,
      210986., 230685., 250384., 270083., 289782., 14116.,  34011.,  53906.,
      73801.,  93696.,  113591., 133486., 153381., 173276., 193171., 213066.,
      232961., 252856., 272751., 292646., 14236.,  34327.,  54418.,  74509.,
      94600.,  114691., 134782., 154873., 174964., 195055., 215146., 235237.,
      255328., 275419., 295510., 14356.,  34643.,  54930.,  75217.,  95504.,
      115791., 136078., 156365., 176652., 196939., 217226., 237513., 257800.,
      278087., 298374., 14476.,  34959.,  55442.,  75925.,  96408.,  116891.,
      137374., 157857., 178340., 198823., 219306., 239789., 260272., 280755.,
      301238., 14596.,  35275.,  55954.,  76633.,  97312.,  117991., 138670.,
      159349., 180028., 200707., 221386., 242065., 262744., 283423., 304102.,
      14716.,  35591.,  56466.,  77341.,  98216.,  119091., 139966., 160841.,
      181716., 202591., 223466., 244341., 265216., 286091., 306966., 14836.,
      35907.,  56978.,  78049.,  99120.,  120191., 141262., 162333., 183404.,
      204475., 225546., 246617., 267688., 288759., 309830., 14956.,  36223.,
      57490.,  78757.,  100024., 121291., 142558., 163825., 185092., 206359.,
      227626., 248893., 270160., 291427., 312694., 15076.,  36539.,  58002.,
      79465.,  100928., 122391., 143854., 165317., 186780., 208243., 229706.,
      251169., 272632., 294095., 315558., 15196.,  36855.,  58514.,  80173.,
      101832., 123491., 145150., 166809., 188468., 210127., 231786., 253445.,
      275104., 296763., 318422., 15316.,  37171.,  59026.,  80881.,  102736.,
      124591., 146446., 168301., 190156., 212011., 233866., 255721., 277576.,
      299431., 321286., 15436.,  37487.,  59538.,  81589.,  103640., 125691.,
      147742., 169793., 191844., 213895., 235946., 257997., 280048., 302099.,
      324150.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13756.,  33063.,  52370.,  71677.,  90984.,  110291., 129598., 148905.,
      168212., 187519., 206826., 226133., 245440., 264747., 284054., 303361.,
      13877.,  33380.,  52883.,  72386.,  91889.,  111392., 130895., 150398.,
      169901., 189404., 208907., 228410., 247913., 267416., 286919., 306422.,
      13998.,  33697.,  53396.,  73095.,  92794.,  112493., 132192., 151891.,
      171590., 191289., 210988., 230687., 250386., 270085., 289784., 309483.,
      14119.,  34014.,  53909.,  73804.,  93699.,  113594., 133489., 153384.,
      173279., 193174., 213069., 232964., 252859., 272754., 292649., 312544.,
      14240.,  34331.,  54422.,  74513.,  94604.,  114695., 134786., 154877.,
      174968., 195059., 215150., 235241., 255332., 275423., 295514., 315605.,
      14361.,  34648.,  54935.,  75222.,  95509.,  115796., 136083., 156370.,
      176657., 196944., 217231., 237518., 257805., 278092., 298379., 318666.,
      14482.,  34965.,  55448.,  75931.,  96414.,  116897., 137380., 157863.,
      178346., 198829., 219312., 239795., 260278., 280761., 301244., 321727.,
      14603.,  35282.,  55961.,  76640.,  97319.,  117998., 138677., 159356.,
      180035., 200714., 221393., 242072., 262751., 283430., 304109., 324788.,
      14724.,  35599.,  56474.,  77349.,  98224.,  119099., 139974., 160849.,
      181724., 202599., 223474., 244349., 265224., 286099., 306974., 327849.,
      14845.,  35916.,  56987.,  78058.,  99129.,  120200., 141271., 162342.,
      183413., 204484., 225555., 246626., 267697., 288768., 309839., 330910.,
      14966.,  36233.,  57500.,  78767.,  100034., 121301., 142568., 163835.,
      185102., 206369., 227636., 248903., 270170., 291437., 312704., 333971.,
      15087.,  36550.,  58013.,  79476.,  100939., 122402., 143865., 165328.,
      186791., 208254., 229717., 251180., 272643., 294106., 315569., 337032.,
      15208.,  36867.,  58526.,  80185.,  101844., 123503., 145162., 166821.,
      188480., 210139., 231798., 253457., 275116., 296775., 318434., 340093.,
      15329.,  37184.,  59039.,  80894.,  102749., 124604., 146459., 168314.,
      190169., 212024., 233879., 255734., 277589., 299444., 321299., 343154.,
      15450.,  37501.,  59552.,  81603.,  103654., 125705., 147756., 169807.,
      191858., 213909., 235960., 258011., 280062., 302113., 324164., 346215.};
  const int batches = 1;
  const int m = 15;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16921.,  40772.,  64623.,  88474.,  112325., 136176., 160027., 183878.,
      207729., 231580., 255431., 279282., 303133., 326984., 17055.,  41131.,
      65207.,  89283.,  113359., 137435., 161511., 185587., 209663., 233739.,
      257815., 281891., 305967., 330043., 17189.,  41490.,  65791.,  90092.,
      114393., 138694., 162995., 187296., 211597., 235898., 260199., 284500.,
      308801., 333102., 17323.,  41849.,  66375.,  90901.,  115427., 139953.,
      164479., 189005., 213531., 238057., 262583., 287109., 311635., 336161.,
      17457.,  42208.,  66959.,  91710.,  116461., 141212., 165963., 190714.,
      215465., 240216., 264967., 289718., 314469., 339220., 17591.,  42567.,
      67543.,  92519.,  117495., 142471., 167447., 192423., 217399., 242375.,
      267351., 292327., 317303., 342279., 17725.,  42926.,  68127.,  93328.,
      118529., 143730., 168931., 194132., 219333., 244534., 269735., 294936.,
      320137., 345338., 17859.,  43285.,  68711.,  94137.,  119563., 144989.,
      170415., 195841., 221267., 246693., 272119., 297545., 322971., 348397.,
      17993.,  43644.,  69295.,  94946.,  120597., 146248., 171899., 197550.,
      223201., 248852., 274503., 300154., 325805., 351456., 18127.,  44003.,
      69879.,  95755.,  121631., 147507., 173383., 199259., 225135., 251011.,
      276887., 302763., 328639., 354515., 18261.,  44362.,  70463.,  96564.,
      122665., 148766., 174867., 200968., 227069., 253170., 279271., 305372.,
      331473., 357574., 18395.,  44721.,  71047.,  97373.,  123699., 150025.,
      176351., 202677., 229003., 255329., 281655., 307981., 334307., 360633.,
      18529.,  45080.,  71631.,  98182.,  124733., 151284., 177835., 204386.,
      230937., 257488., 284039., 310590., 337141., 363692., 18663.,  45439.,
      72215.,  98991.,  125767., 152543., 179319., 206095., 232871., 259647.,
      286423., 313199., 339975., 366751., 18797.,  45798.,  72799.,  99800.,
      126801., 153802., 180803., 207804., 234805., 261806., 288807., 315808.,
      342809., 369810.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16921.,  40772.,  64623.,  88474.,  112325., 136176., 160027., 183878.,
      207729., 231580., 255431., 279282., 303133., 326984., 350835., 17056.,
      41132.,  65208.,  89284.,  113360., 137436., 161512., 185588., 209664.,
      233740., 257816., 281892., 305968., 330044., 354120., 17191.,  41492.,
      65793.,  90094.,  114395., 138696., 162997., 187298., 211599., 235900.,
      260201., 284502., 308803., 333104., 357405., 17326.,  41852.,  66378.,
      90904.,  115430., 139956., 164482., 189008., 213534., 238060., 262586.,
      287112., 311638., 336164., 360690., 17461.,  42212.,  66963.,  91714.,
      116465., 141216., 165967., 190718., 215469., 240220., 264971., 289722.,
      314473., 339224., 363975., 17596.,  42572.,  67548.,  92524.,  117500.,
      142476., 167452., 192428., 217404., 242380., 267356., 292332., 317308.,
      342284., 367260., 17731.,  42932.,  68133.,  93334.,  118535., 143736.,
      168937., 194138., 219339., 244540., 269741., 294942., 320143., 345344.,
      370545., 17866.,  43292.,  68718.,  94144.,  119570., 144996., 170422.,
      195848., 221274., 246700., 272126., 297552., 322978., 348404., 373830.,
      18001.,  43652.,  69303.,  94954.,  120605., 146256., 171907., 197558.,
      223209., 248860., 274511., 300162., 325813., 351464., 377115., 18136.,
      44012.,  69888.,  95764.,  121640., 147516., 173392., 199268., 225144.,
      251020., 276896., 302772., 328648., 354524., 380400., 18271.,  44372.,
      70473.,  96574.,  122675., 148776., 174877., 200978., 227079., 253180.,
      279281., 305382., 331483., 357584., 383685., 18406.,  44732.,  71058.,
      97384.,  123710., 150036., 176362., 202688., 229014., 255340., 281666.,
      307992., 334318., 360644., 386970., 18541.,  45092.,  71643.,  98194.,
      124745., 151296., 177847., 204398., 230949., 257500., 284051., 310602.,
      337153., 363704., 390255., 18676.,  45452.,  72228.,  99004.,  125780.,
      152556., 179332., 206108., 232884., 259660., 286436., 313212., 339988.,
      366764., 393540., 18811.,  45812.,  72813.,  99814.,  126815., 153816.,
      180817., 207818., 234819., 261820., 288821., 315822., 342823., 369824.,
      396825.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      16921.,  40772.,  64623.,  88474.,  112325., 136176., 160027., 183878.,
      207729., 231580., 255431., 279282., 303133., 326984., 350835., 374686.,
      17057.,  41133.,  65209.,  89285.,  113361., 137437., 161513., 185589.,
      209665., 233741., 257817., 281893., 305969., 330045., 354121., 378197.,
      17193.,  41494.,  65795.,  90096.,  114397., 138698., 162999., 187300.,
      211601., 235902., 260203., 284504., 308805., 333106., 357407., 381708.,
      17329.,  41855.,  66381.,  90907.,  115433., 139959., 164485., 189011.,
      213537., 238063., 262589., 287115., 311641., 336167., 360693., 385219.,
      17465.,  42216.,  66967.,  91718.,  116469., 141220., 165971., 190722.,
      215473., 240224., 264975., 289726., 314477., 339228., 363979., 388730.,
      17601.,  42577.,  67553.,  92529.,  117505., 142481., 167457., 192433.,
      217409., 242385., 267361., 292337., 317313., 342289., 367265., 392241.,
      17737.,  42938.,  68139.,  93340.,  118541., 143742., 168943., 194144.,
      219345., 244546., 269747., 294948., 320149., 345350., 370551., 395752.,
      17873.,  43299.,  68725.,  94151.,  119577., 145003., 170429., 195855.,
      221281., 246707., 272133., 297559., 322985., 348411., 373837., 399263.,
      18009.,  43660.,  69311.,  94962.,  120613., 146264., 171915., 197566.,
      223217., 248868., 274519., 300170., 325821., 351472., 377123., 402774.,
      18145.,  44021.,  69897.,  95773.,  121649., 147525., 173401., 199277.,
      225153., 251029., 276905., 302781., 328657., 354533., 380409., 406285.,
      18281.,  44382.,  70483.,  96584.,  122685., 148786., 174887., 200988.,
      227089., 253190., 279291., 305392., 331493., 357594., 383695., 409796.,
      18417.,  44743.,  71069.,  97395.,  123721., 150047., 176373., 202699.,
      229025., 255351., 281677., 308003., 334329., 360655., 386981., 413307.,
      18553.,  45104.,  71655.,  98206.,  124757., 151308., 177859., 204410.,
      230961., 257512., 284063., 310614., 337165., 363716., 390267., 416818.,
      18689.,  45465.,  72241.,  99017.,  125793., 152569., 179345., 206121.,
      232897., 259673., 286449., 313225., 340001., 366777., 393553., 420329.,
      18825.,  45826.,  72827.,  99828.,  126829., 153830., 180831., 207832.,
      234833., 261834., 288835., 315836., 342837., 369838., 396839., 423840.};
  const int batches = 1;
  const int m = 15;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20537.,  49594.,  78651.,  107708., 136765., 165822., 194879., 223936.,
      252993., 282050., 311107., 340164., 369221., 398278., 20687.,  50000.,
      79313.,  108626., 137939., 167252., 196565., 225878., 255191., 284504.,
      313817., 343130., 372443., 401756., 20837.,  50406.,  79975.,  109544.,
      139113., 168682., 198251., 227820., 257389., 286958., 316527., 346096.,
      375665., 405234., 20987.,  50812.,  80637.,  110462., 140287., 170112.,
      199937., 229762., 259587., 289412., 319237., 349062., 378887., 408712.,
      21137.,  51218.,  81299.,  111380., 141461., 171542., 201623., 231704.,
      261785., 291866., 321947., 352028., 382109., 412190., 21287.,  51624.,
      81961.,  112298., 142635., 172972., 203309., 233646., 263983., 294320.,
      324657., 354994., 385331., 415668., 21437.,  52030.,  82623.,  113216.,
      143809., 174402., 204995., 235588., 266181., 296774., 327367., 357960.,
      388553., 419146., 21587.,  52436.,  83285.,  114134., 144983., 175832.,
      206681., 237530., 268379., 299228., 330077., 360926., 391775., 422624.,
      21737.,  52842.,  83947.,  115052., 146157., 177262., 208367., 239472.,
      270577., 301682., 332787., 363892., 394997., 426102., 21887.,  53248.,
      84609.,  115970., 147331., 178692., 210053., 241414., 272775., 304136.,
      335497., 366858., 398219., 429580., 22037.,  53654.,  85271.,  116888.,
      148505., 180122., 211739., 243356., 274973., 306590., 338207., 369824.,
      401441., 433058., 22187.,  54060.,  85933.,  117806., 149679., 181552.,
      213425., 245298., 277171., 309044., 340917., 372790., 404663., 436536.,
      22337.,  54466.,  86595.,  118724., 150853., 182982., 215111., 247240.,
      279369., 311498., 343627., 375756., 407885., 440014., 22487.,  54872.,
      87257.,  119642., 152027., 184412., 216797., 249182., 281567., 313952.,
      346337., 378722., 411107., 443492., 22637.,  55278.,  87919.,  120560.,
      153201., 185842., 218483., 251124., 283765., 316406., 349047., 381688.,
      414329., 446970.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20537.,  49594.,  78651.,  107708., 136765., 165822., 194879., 223936.,
      252993., 282050., 311107., 340164., 369221., 398278., 427335., 20688.,
      50001.,  79314.,  108627., 137940., 167253., 196566., 225879., 255192.,
      284505., 313818., 343131., 372444., 401757., 431070., 20839.,  50408.,
      79977.,  109546., 139115., 168684., 198253., 227822., 257391., 286960.,
      316529., 346098., 375667., 405236., 434805., 20990.,  50815.,  80640.,
      110465., 140290., 170115., 199940., 229765., 259590., 289415., 319240.,
      349065., 378890., 408715., 438540., 21141.,  51222.,  81303.,  111384.,
      141465., 171546., 201627., 231708., 261789., 291870., 321951., 352032.,
      382113., 412194., 442275., 21292.,  51629.,  81966.,  112303., 142640.,
      172977., 203314., 233651., 263988., 294325., 324662., 354999., 385336.,
      415673., 446010., 21443.,  52036.,  82629.,  113222., 143815., 174408.,
      205001., 235594., 266187., 296780., 327373., 357966., 388559., 419152.,
      449745., 21594.,  52443.,  83292.,  114141., 144990., 175839., 206688.,
      237537., 268386., 299235., 330084., 360933., 391782., 422631., 453480.,
      21745.,  52850.,  83955.,  115060., 146165., 177270., 208375., 239480.,
      270585., 301690., 332795., 363900., 395005., 426110., 457215., 21896.,
      53257.,  84618.,  115979., 147340., 178701., 210062., 241423., 272784.,
      304145., 335506., 366867., 398228., 429589., 460950., 22047.,  53664.,
      85281.,  116898., 148515., 180132., 211749., 243366., 274983., 306600.,
      338217., 369834., 401451., 433068., 464685., 22198.,  54071.,  85944.,
      117817., 149690., 181563., 213436., 245309., 277182., 309055., 340928.,
      372801., 404674., 436547., 468420., 22349.,  54478.,  86607.,  118736.,
      150865., 182994., 215123., 247252., 279381., 311510., 343639., 375768.,
      407897., 440026., 472155., 22500.,  54885.,  87270.,  119655., 152040.,
      184425., 216810., 249195., 281580., 313965., 346350., 378735., 411120.,
      443505., 475890., 22651.,  55292.,  87933.,  120574., 153215., 185856.,
      218497., 251138., 283779., 316420., 349061., 381702., 414343., 446984.,
      479625.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M15xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20537.,  49594.,  78651.,  107708., 136765., 165822., 194879., 223936.,
      252993., 282050., 311107., 340164., 369221., 398278., 427335., 456392.,
      20689.,  50002.,  79315.,  108628., 137941., 167254., 196567., 225880.,
      255193., 284506., 313819., 343132., 372445., 401758., 431071., 460384.,
      20841.,  50410.,  79979.,  109548., 139117., 168686., 198255., 227824.,
      257393., 286962., 316531., 346100., 375669., 405238., 434807., 464376.,
      20993.,  50818.,  80643.,  110468., 140293., 170118., 199943., 229768.,
      259593., 289418., 319243., 349068., 378893., 408718., 438543., 468368.,
      21145.,  51226.,  81307.,  111388., 141469., 171550., 201631., 231712.,
      261793., 291874., 321955., 352036., 382117., 412198., 442279., 472360.,
      21297.,  51634.,  81971.,  112308., 142645., 172982., 203319., 233656.,
      263993., 294330., 324667., 355004., 385341., 415678., 446015., 476352.,
      21449.,  52042.,  82635.,  113228., 143821., 174414., 205007., 235600.,
      266193., 296786., 327379., 357972., 388565., 419158., 449751., 480344.,
      21601.,  52450.,  83299.,  114148., 144997., 175846., 206695., 237544.,
      268393., 299242., 330091., 360940., 391789., 422638., 453487., 484336.,
      21753.,  52858.,  83963.,  115068., 146173., 177278., 208383., 239488.,
      270593., 301698., 332803., 363908., 395013., 426118., 457223., 488328.,
      21905.,  53266.,  84627.,  115988., 147349., 178710., 210071., 241432.,
      272793., 304154., 335515., 366876., 398237., 429598., 460959., 492320.,
      22057.,  53674.,  85291.,  116908., 148525., 180142., 211759., 243376.,
      274993., 306610., 338227., 369844., 401461., 433078., 464695., 496312.,
      22209.,  54082.,  85955.,  117828., 149701., 181574., 213447., 245320.,
      277193., 309066., 340939., 372812., 404685., 436558., 468431., 500304.,
      22361.,  54490.,  86619.,  118748., 150877., 183006., 215135., 247264.,
      279393., 311522., 343651., 375780., 407909., 440038., 472167., 504296.,
      22513.,  54898.,  87283.,  119668., 152053., 184438., 216823., 249208.,
      281593., 313978., 346363., 378748., 411133., 443518., 475903., 508288.,
      22665.,  55306.,  87947.,  120588., 153229., 185870., 218511., 251152.,
      283793., 316434., 349075., 381716., 414357., 446998., 479639., 512280.};
  const int batches = 1;
  const int m = 15;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK14xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14666.,  35247.,  55828.,  76409.,  96990.,  117571., 138152., 158733.,
      179314., 199895., 220476., 241057., 261638., 282219., 14785.,  35562.,
      56339.,  77116.,  97893.,  118670., 139447., 160224., 181001., 201778.,
      222555., 243332., 264109., 284886., 14904.,  35877.,  56850.,  77823.,
      98796.,  119769., 140742., 161715., 182688., 203661., 224634., 245607.,
      266580., 287553., 15023.,  36192.,  57361.,  78530.,  99699.,  120868.,
      142037., 163206., 184375., 205544., 226713., 247882., 269051., 290220.,
      15142.,  36507.,  57872.,  79237.,  100602., 121967., 143332., 164697.,
      186062., 207427., 228792., 250157., 271522., 292887., 15261.,  36822.,
      58383.,  79944.,  101505., 123066., 144627., 166188., 187749., 209310.,
      230871., 252432., 273993., 295554., 15380.,  37137.,  58894.,  80651.,
      102408., 124165., 145922., 167679., 189436., 211193., 232950., 254707.,
      276464., 298221., 15499.,  37452.,  59405.,  81358.,  103311., 125264.,
      147217., 169170., 191123., 213076., 235029., 256982., 278935., 300888.,
      15618.,  37767.,  59916.,  82065.,  104214., 126363., 148512., 170661.,
      192810., 214959., 237108., 259257., 281406., 303555., 15737.,  38082.,
      60427.,  82772.,  105117., 127462., 149807., 172152., 194497., 216842.,
      239187., 261532., 283877., 306222., 15856.,  38397.,  60938.,  83479.,
      106020., 128561., 151102., 173643., 196184., 218725., 241266., 263807.,
      286348., 308889., 15975.,  38712.,  61449.,  84186.,  106923., 129660.,
      152397., 175134., 197871., 220608., 243345., 266082., 288819., 311556.,
      16094.,  39027.,  61960.,  84893.,  107826., 130759., 153692., 176625.,
      199558., 222491., 245424., 268357., 291290., 314223., 16213.,  39342.,
      62471.,  85600.,  108729., 131858., 154987., 178116., 201245., 224374.,
      247503., 270632., 293761., 316890., 16332.,  39657.,  62982.,  86307.,
      109632., 132957., 156282., 179607., 202932., 226257., 249582., 272907.,
      296232., 319557., 16451.,  39972.,  63493.,  87014.,  110535., 134056.,
      157577., 181098., 204619., 228140., 251661., 275182., 298703., 322224.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK14xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14666.,  35247.,  55828.,  76409.,  96990.,  117571., 138152., 158733.,
      179314., 199895., 220476., 241057., 261638., 282219., 302800., 14786.,
      35563.,  56340.,  77117.,  97894.,  118671., 139448., 160225., 181002.,
      201779., 222556., 243333., 264110., 284887., 305664., 14906.,  35879.,
      56852.,  77825.,  98798.,  119771., 140744., 161717., 182690., 203663.,
      224636., 245609., 266582., 287555., 308528., 15026.,  36195.,  57364.,
      78533.,  99702.,  120871., 142040., 163209., 184378., 205547., 226716.,
      247885., 269054., 290223., 311392., 15146.,  36511.,  57876.,  79241.,
      100606., 121971., 143336., 164701., 186066., 207431., 228796., 250161.,
      271526., 292891., 314256., 15266.,  36827.,  58388.,  79949.,  101510.,
      123071., 144632., 166193., 187754., 209315., 230876., 252437., 273998.,
      295559., 317120., 15386.,  37143.,  58900.,  80657.,  102414., 124171.,
      145928., 167685., 189442., 211199., 232956., 254713., 276470., 298227.,
      319984., 15506.,  37459.,  59412.,  81365.,  103318., 125271., 147224.,
      169177., 191130., 213083., 235036., 256989., 278942., 300895., 322848.,
      15626.,  37775.,  59924.,  82073.,  104222., 126371., 148520., 170669.,
      192818., 214967., 237116., 259265., 281414., 303563., 325712., 15746.,
      38091.,  60436.,  82781.,  105126., 127471., 149816., 172161., 194506.,
      216851., 239196., 261541., 283886., 306231., 328576., 15866.,  38407.,
      60948.,  83489.,  106030., 128571., 151112., 173653., 196194., 218735.,
      241276., 263817., 286358., 308899., 331440., 15986.,  38723.,  61460.,
      84197.,  106934., 129671., 152408., 175145., 197882., 220619., 243356.,
      266093., 288830., 311567., 334304., 16106.,  39039.,  61972.,  84905.,
      107838., 130771., 153704., 176637., 199570., 222503., 245436., 268369.,
      291302., 314235., 337168., 16226.,  39355.,  62484.,  85613.,  108742.,
      131871., 155000., 178129., 201258., 224387., 247516., 270645., 293774.,
      316903., 340032., 16346.,  39671.,  62996.,  86321.,  109646., 132971.,
      156296., 179621., 202946., 226271., 249596., 272921., 296246., 319571.,
      342896., 16466.,  39987.,  63508.,  87029.,  110550., 134071., 157592.,
      181113., 204634., 228155., 251676., 275197., 298718., 322239., 345760.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK14xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      14666.,  35247.,  55828.,  76409.,  96990.,  117571., 138152., 158733.,
      179314., 199895., 220476., 241057., 261638., 282219., 302800., 323381.,
      14787.,  35564.,  56341.,  77118.,  97895.,  118672., 139449., 160226.,
      181003., 201780., 222557., 243334., 264111., 284888., 305665., 326442.,
      14908.,  35881.,  56854.,  77827.,  98800.,  119773., 140746., 161719.,
      182692., 203665., 224638., 245611., 266584., 287557., 308530., 329503.,
      15029.,  36198.,  57367.,  78536.,  99705.,  120874., 142043., 163212.,
      184381., 205550., 226719., 247888., 269057., 290226., 311395., 332564.,
      15150.,  36515.,  57880.,  79245.,  100610., 121975., 143340., 164705.,
      186070., 207435., 228800., 250165., 271530., 292895., 314260., 335625.,
      15271.,  36832.,  58393.,  79954.,  101515., 123076., 144637., 166198.,
      187759., 209320., 230881., 252442., 274003., 295564., 317125., 338686.,
      15392.,  37149.,  58906.,  80663.,  102420., 124177., 145934., 167691.,
      189448., 211205., 232962., 254719., 276476., 298233., 319990., 341747.,
      15513.,  37466.,  59419.,  81372.,  103325., 125278., 147231., 169184.,
      191137., 213090., 235043., 256996., 278949., 300902., 322855., 344808.,
      15634.,  37783.,  59932.,  82081.,  104230., 126379., 148528., 170677.,
      192826., 214975., 237124., 259273., 281422., 303571., 325720., 347869.,
      15755.,  38100.,  60445.,  82790.,  105135., 127480., 149825., 172170.,
      194515., 216860., 239205., 261550., 283895., 306240., 328585., 350930.,
      15876.,  38417.,  60958.,  83499.,  106040., 128581., 151122., 173663.,
      196204., 218745., 241286., 263827., 286368., 308909., 331450., 353991.,
      15997.,  38734.,  61471.,  84208.,  106945., 129682., 152419., 175156.,
      197893., 220630., 243367., 266104., 288841., 311578., 334315., 357052.,
      16118.,  39051.,  61984.,  84917.,  107850., 130783., 153716., 176649.,
      199582., 222515., 245448., 268381., 291314., 314247., 337180., 360113.,
      16239.,  39368.,  62497.,  85626.,  108755., 131884., 155013., 178142.,
      201271., 224400., 247529., 270658., 293787., 316916., 340045., 363174.,
      16360.,  39685.,  63010.,  86335.,  109660., 132985., 156310., 179635.,
      202960., 226285., 249610., 272935., 296260., 319585., 342910., 366235.,
      16481.,  40002.,  63523.,  87044.,  110565., 134086., 157607., 181128.,
      204649., 228170., 251691., 275212., 298733., 322254., 345775., 369296.};
  const int batches = 1;
  const int m = 16;
  const int k = 14;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK15xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18041.,  43467.,  68893.,  94319.,  119745., 145171., 170597., 196023.,
      221449., 246875., 272301., 297727., 323153., 348579., 18175.,  43826.,
      69477.,  95128.,  120779., 146430., 172081., 197732., 223383., 249034.,
      274685., 300336., 325987., 351638., 18309.,  44185.,  70061.,  95937.,
      121813., 147689., 173565., 199441., 225317., 251193., 277069., 302945.,
      328821., 354697., 18443.,  44544.,  70645.,  96746.,  122847., 148948.,
      175049., 201150., 227251., 253352., 279453., 305554., 331655., 357756.,
      18577.,  44903.,  71229.,  97555.,  123881., 150207., 176533., 202859.,
      229185., 255511., 281837., 308163., 334489., 360815., 18711.,  45262.,
      71813.,  98364.,  124915., 151466., 178017., 204568., 231119., 257670.,
      284221., 310772., 337323., 363874., 18845.,  45621.,  72397.,  99173.,
      125949., 152725., 179501., 206277., 233053., 259829., 286605., 313381.,
      340157., 366933., 18979.,  45980.,  72981.,  99982.,  126983., 153984.,
      180985., 207986., 234987., 261988., 288989., 315990., 342991., 369992.,
      19113.,  46339.,  73565.,  100791., 128017., 155243., 182469., 209695.,
      236921., 264147., 291373., 318599., 345825., 373051., 19247.,  46698.,
      74149.,  101600., 129051., 156502., 183953., 211404., 238855., 266306.,
      293757., 321208., 348659., 376110., 19381.,  47057.,  74733.,  102409.,
      130085., 157761., 185437., 213113., 240789., 268465., 296141., 323817.,
      351493., 379169., 19515.,  47416.,  75317.,  103218., 131119., 159020.,
      186921., 214822., 242723., 270624., 298525., 326426., 354327., 382228.,
      19649.,  47775.,  75901.,  104027., 132153., 160279., 188405., 216531.,
      244657., 272783., 300909., 329035., 357161., 385287., 19783.,  48134.,
      76485.,  104836., 133187., 161538., 189889., 218240., 246591., 274942.,
      303293., 331644., 359995., 388346., 19917.,  48493.,  77069.,  105645.,
      134221., 162797., 191373., 219949., 248525., 277101., 305677., 334253.,
      362829., 391405., 20051.,  48852.,  77653.,  106454., 135255., 164056.,
      192857., 221658., 250459., 279260., 308061., 336862., 365663., 394464.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK15xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18041.,  43467.,  68893.,  94319.,  119745., 145171., 170597., 196023.,
      221449., 246875., 272301., 297727., 323153., 348579., 374005., 18176.,
      43827.,  69478.,  95129.,  120780., 146431., 172082., 197733., 223384.,
      249035., 274686., 300337., 325988., 351639., 377290., 18311.,  44187.,
      70063.,  95939.,  121815., 147691., 173567., 199443., 225319., 251195.,
      277071., 302947., 328823., 354699., 380575., 18446.,  44547.,  70648.,
      96749.,  122850., 148951., 175052., 201153., 227254., 253355., 279456.,
      305557., 331658., 357759., 383860., 18581.,  44907.,  71233.,  97559.,
      123885., 150211., 176537., 202863., 229189., 255515., 281841., 308167.,
      334493., 360819., 387145., 18716.,  45267.,  71818.,  98369.,  124920.,
      151471., 178022., 204573., 231124., 257675., 284226., 310777., 337328.,
      363879., 390430., 18851.,  45627.,  72403.,  99179.,  125955., 152731.,
      179507., 206283., 233059., 259835., 286611., 313387., 340163., 366939.,
      393715., 18986.,  45987.,  72988.,  99989.,  126990., 153991., 180992.,
      207993., 234994., 261995., 288996., 315997., 342998., 369999., 397000.,
      19121.,  46347.,  73573.,  100799., 128025., 155251., 182477., 209703.,
      236929., 264155., 291381., 318607., 345833., 373059., 400285., 19256.,
      46707.,  74158.,  101609., 129060., 156511., 183962., 211413., 238864.,
      266315., 293766., 321217., 348668., 376119., 403570., 19391.,  47067.,
      74743.,  102419., 130095., 157771., 185447., 213123., 240799., 268475.,
      296151., 323827., 351503., 379179., 406855., 19526.,  47427.,  75328.,
      103229., 131130., 159031., 186932., 214833., 242734., 270635., 298536.,
      326437., 354338., 382239., 410140., 19661.,  47787.,  75913.,  104039.,
      132165., 160291., 188417., 216543., 244669., 272795., 300921., 329047.,
      357173., 385299., 413425., 19796.,  48147.,  76498.,  104849., 133200.,
      161551., 189902., 218253., 246604., 274955., 303306., 331657., 360008.,
      388359., 416710., 19931.,  48507.,  77083.,  105659., 134235., 162811.,
      191387., 219963., 248539., 277115., 305691., 334267., 362843., 391419.,
      419995., 20066.,  48867.,  77668.,  106469., 135270., 164071., 192872.,
      221673., 250474., 279275., 308076., 336877., 365678., 394479., 423280.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK15xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      18041.,  43467.,  68893.,  94319.,  119745., 145171., 170597., 196023.,
      221449., 246875., 272301., 297727., 323153., 348579., 374005., 399431.,
      18177.,  43828.,  69479.,  95130.,  120781., 146432., 172083., 197734.,
      223385., 249036., 274687., 300338., 325989., 351640., 377291., 402942.,
      18313.,  44189.,  70065.,  95941.,  121817., 147693., 173569., 199445.,
      225321., 251197., 277073., 302949., 328825., 354701., 380577., 406453.,
      18449.,  44550.,  70651.,  96752.,  122853., 148954., 175055., 201156.,
      227257., 253358., 279459., 305560., 331661., 357762., 383863., 409964.,
      18585.,  44911.,  71237.,  97563.,  123889., 150215., 176541., 202867.,
      229193., 255519., 281845., 308171., 334497., 360823., 387149., 413475.,
      18721.,  45272.,  71823.,  98374.,  124925., 151476., 178027., 204578.,
      231129., 257680., 284231., 310782., 337333., 363884., 390435., 416986.,
      18857.,  45633.,  72409.,  99185.,  125961., 152737., 179513., 206289.,
      233065., 259841., 286617., 313393., 340169., 366945., 393721., 420497.,
      18993.,  45994.,  72995.,  99996.,  126997., 153998., 180999., 208000.,
      235001., 262002., 289003., 316004., 343005., 370006., 397007., 424008.,
      19129.,  46355.,  73581.,  100807., 128033., 155259., 182485., 209711.,
      236937., 264163., 291389., 318615., 345841., 373067., 400293., 427519.,
      19265.,  46716.,  74167.,  101618., 129069., 156520., 183971., 211422.,
      238873., 266324., 293775., 321226., 348677., 376128., 403579., 431030.,
      19401.,  47077.,  74753.,  102429., 130105., 157781., 185457., 213133.,
      240809., 268485., 296161., 323837., 351513., 379189., 406865., 434541.,
      19537.,  47438.,  75339.,  103240., 131141., 159042., 186943., 214844.,
      242745., 270646., 298547., 326448., 354349., 382250., 410151., 438052.,
      19673.,  47799.,  75925.,  104051., 132177., 160303., 188429., 216555.,
      244681., 272807., 300933., 329059., 357185., 385311., 413437., 441563.,
      19809.,  48160.,  76511.,  104862., 133213., 161564., 189915., 218266.,
      246617., 274968., 303319., 331670., 360021., 388372., 416723., 445074.,
      19945.,  48521.,  77097.,  105673., 134249., 162825., 191401., 219977.,
      248553., 277129., 305705., 334281., 362857., 391433., 420009., 448585.,
      20081.,  48882.,  77683.,  106484., 135285., 164086., 192887., 221688.,
      250489., 279290., 308091., 336892., 365693., 394494., 423295., 452096.};
  const int batches = 1;
  const int m = 16;
  const int k = 15;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK16xN14) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21897.,  52874.,  83851.,  114828., 145805., 176782., 207759., 238736.,
      269713., 300690., 331667., 362644., 393621., 424598., 22047.,  53280.,
      84513.,  115746., 146979., 178212., 209445., 240678., 271911., 303144.,
      334377., 365610., 396843., 428076., 22197.,  53686.,  85175.,  116664.,
      148153., 179642., 211131., 242620., 274109., 305598., 337087., 368576.,
      400065., 431554., 22347.,  54092.,  85837.,  117582., 149327., 181072.,
      212817., 244562., 276307., 308052., 339797., 371542., 403287., 435032.,
      22497.,  54498.,  86499.,  118500., 150501., 182502., 214503., 246504.,
      278505., 310506., 342507., 374508., 406509., 438510., 22647.,  54904.,
      87161.,  119418., 151675., 183932., 216189., 248446., 280703., 312960.,
      345217., 377474., 409731., 441988., 22797.,  55310.,  87823.,  120336.,
      152849., 185362., 217875., 250388., 282901., 315414., 347927., 380440.,
      412953., 445466., 22947.,  55716.,  88485.,  121254., 154023., 186792.,
      219561., 252330., 285099., 317868., 350637., 383406., 416175., 448944.,
      23097.,  56122.,  89147.,  122172., 155197., 188222., 221247., 254272.,
      287297., 320322., 353347., 386372., 419397., 452422., 23247.,  56528.,
      89809.,  123090., 156371., 189652., 222933., 256214., 289495., 322776.,
      356057., 389338., 422619., 455900., 23397.,  56934.,  90471.,  124008.,
      157545., 191082., 224619., 258156., 291693., 325230., 358767., 392304.,
      425841., 459378., 23547.,  57340.,  91133.,  124926., 158719., 192512.,
      226305., 260098., 293891., 327684., 361477., 395270., 429063., 462856.,
      23697.,  57746.,  91795.,  125844., 159893., 193942., 227991., 262040.,
      296089., 330138., 364187., 398236., 432285., 466334., 23847.,  58152.,
      92457.,  126762., 161067., 195372., 229677., 263982., 298287., 332592.,
      366897., 401202., 435507., 469812., 23997.,  58558.,  93119.,  127680.,
      162241., 196802., 231363., 265924., 300485., 335046., 369607., 404168.,
      438729., 473290., 24147.,  58964.,  93781.,  128598., 163415., 198232.,
      233049., 267866., 302683., 337500., 372317., 407134., 441951., 476768.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 14;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK16xN15) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21897.,  52874.,  83851.,  114828., 145805., 176782., 207759., 238736.,
      269713., 300690., 331667., 362644., 393621., 424598., 455575., 22048.,
      53281.,  84514.,  115747., 146980., 178213., 209446., 240679., 271912.,
      303145., 334378., 365611., 396844., 428077., 459310., 22199.,  53688.,
      85177.,  116666., 148155., 179644., 211133., 242622., 274111., 305600.,
      337089., 368578., 400067., 431556., 463045., 22350.,  54095.,  85840.,
      117585., 149330., 181075., 212820., 244565., 276310., 308055., 339800.,
      371545., 403290., 435035., 466780., 22501.,  54502.,  86503.,  118504.,
      150505., 182506., 214507., 246508., 278509., 310510., 342511., 374512.,
      406513., 438514., 470515., 22652.,  54909.,  87166.,  119423., 151680.,
      183937., 216194., 248451., 280708., 312965., 345222., 377479., 409736.,
      441993., 474250., 22803.,  55316.,  87829.,  120342., 152855., 185368.,
      217881., 250394., 282907., 315420., 347933., 380446., 412959., 445472.,
      477985., 22954.,  55723.,  88492.,  121261., 154030., 186799., 219568.,
      252337., 285106., 317875., 350644., 383413., 416182., 448951., 481720.,
      23105.,  56130.,  89155.,  122180., 155205., 188230., 221255., 254280.,
      287305., 320330., 353355., 386380., 419405., 452430., 485455., 23256.,
      56537.,  89818.,  123099., 156380., 189661., 222942., 256223., 289504.,
      322785., 356066., 389347., 422628., 455909., 489190., 23407.,  56944.,
      90481.,  124018., 157555., 191092., 224629., 258166., 291703., 325240.,
      358777., 392314., 425851., 459388., 492925., 23558.,  57351.,  91144.,
      124937., 158730., 192523., 226316., 260109., 293902., 327695., 361488.,
      395281., 429074., 462867., 496660., 23709.,  57758.,  91807.,  125856.,
      159905., 193954., 228003., 262052., 296101., 330150., 364199., 398248.,
      432297., 466346., 500395., 23860.,  58165.,  92470.,  126775., 161080.,
      195385., 229690., 263995., 298300., 332605., 366910., 401215., 435520.,
      469825., 504130., 24011.,  58572.,  93133.,  127694., 162255., 196816.,
      231377., 265938., 300499., 335060., 369621., 404182., 438743., 473304.,
      507865., 24162.,  58979.,  93796.,  128613., 163430., 198247., 233064.,
      267881., 302698., 337515., 372332., 407149., 441966., 476783., 511600.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 15;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}
TYPED_TEST(MatmulBatch1Beta1TrueTrue, M16xK16xN16) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21897.,  52874.,  83851.,  114828., 145805., 176782., 207759., 238736.,
      269713., 300690., 331667., 362644., 393621., 424598., 455575., 486552.,
      22049.,  53282.,  84515.,  115748., 146981., 178214., 209447., 240680.,
      271913., 303146., 334379., 365612., 396845., 428078., 459311., 490544.,
      22201.,  53690.,  85179.,  116668., 148157., 179646., 211135., 242624.,
      274113., 305602., 337091., 368580., 400069., 431558., 463047., 494536.,
      22353.,  54098.,  85843.,  117588., 149333., 181078., 212823., 244568.,
      276313., 308058., 339803., 371548., 403293., 435038., 466783., 498528.,
      22505.,  54506.,  86507.,  118508., 150509., 182510., 214511., 246512.,
      278513., 310514., 342515., 374516., 406517., 438518., 470519., 502520.,
      22657.,  54914.,  87171.,  119428., 151685., 183942., 216199., 248456.,
      280713., 312970., 345227., 377484., 409741., 441998., 474255., 506512.,
      22809.,  55322.,  87835.,  120348., 152861., 185374., 217887., 250400.,
      282913., 315426., 347939., 380452., 412965., 445478., 477991., 510504.,
      22961.,  55730.,  88499.,  121268., 154037., 186806., 219575., 252344.,
      285113., 317882., 350651., 383420., 416189., 448958., 481727., 514496.,
      23113.,  56138.,  89163.,  122188., 155213., 188238., 221263., 254288.,
      287313., 320338., 353363., 386388., 419413., 452438., 485463., 518488.,
      23265.,  56546.,  89827.,  123108., 156389., 189670., 222951., 256232.,
      289513., 322794., 356075., 389356., 422637., 455918., 489199., 522480.,
      23417.,  56954.,  90491.,  124028., 157565., 191102., 224639., 258176.,
      291713., 325250., 358787., 392324., 425861., 459398., 492935., 526472.,
      23569.,  57362.,  91155.,  124948., 158741., 192534., 226327., 260120.,
      293913., 327706., 361499., 395292., 429085., 462878., 496671., 530464.,
      23721.,  57770.,  91819.,  125868., 159917., 193966., 228015., 262064.,
      296113., 330162., 364211., 398260., 432309., 466358., 500407., 534456.,
      23873.,  58178.,  92483.,  126788., 161093., 195398., 229703., 264008.,
      298313., 332618., 366923., 401228., 435533., 469838., 504143., 538448.,
      24025.,  58586.,  93147.,  127708., 162269., 196830., 231391., 265952.,
      300513., 335074., 369635., 404196., 438757., 473318., 507879., 542440.,
      24177.,  58994.,  93811.,  128628., 163445., 198262., 233079., 267896.,
      302713., 337530., 372347., 407164., 441981., 476798., 511615., 546432.};
  const int batches = 1;
  const int m = 16;
  const int k = 16;
  const int n = 16;
  const auto beta = static_cast<DataType>(1);
  const DataType max_input_val = 2048.0;
  this->run(exp_out, batches, m, k, n, beta, 0, 0, 0, max_input_val);
}